Automatisation des flux RSS avec un LLM

Automatisation de la veille

Avec la montée grandissante de l'intelligence artificielle, il est très facile de prendre de mauvaises habitudes. Les capacités des intelligences artificielles actuelles leur permettent de reformuler des textes complexes et d'y ajouter des informations.

J'utilise ce principe pour ma page de veille. Tous les jours, à 19h (à la fin d'une journée de travail), je récupère des flux RSS, les traite, les reformule et les stocke. Par la suite, avec l'affichage front-end, les articles sont envoyés.

Récupérer les RSS:

Pour récupérer des flux RSS avec rss-parser en Node.js, vous pouvez suivre les étapes suivantes:

1. Tout d'abord, installez le module rss-parser en utilisant la commande npm suivante :

npm install rss-parser

2. Ensuite, créez un fichier JavaScript et importez le module rss-parser en utilisant la ligne suivante :

import parser from 'rss-parser';

3. Créez une instance de l'objet Parser :

const parser = new Parser();

4. Utilisez la méthode parseURL () de l'objet Parser pour récupérer le flux RSS à partir de l'URL :

(async () => {
  const feed = await parser.parseURL('<https://www.example.com/feed.xml>');
  console.log(feed.title);
})

5. Vous pouvez ensuite accéder aux différentes propriétés du flux RSS, telles que le titre, la description, les articles, etc.

(async () => {
  const feed = await parser.parseURL('<https://www.example.com/feed.xml>');
  console.log(feed.title);
})(

Tout les champs d’un object pour le RSS de docker sont:

[
  'creator',
  'title',
  'link',
  'pubDate',
  'content:encoded',
  'content:encodedSnippet',
  'dc:creator',
  'content',
  'contentSnippet',
  'guid',
  'categories',
  'isoDate'
]

Voici un exemple complet montrant comment récupérer et afficher les titres des articles d'un flux RSS :

import parser from 'rss-parser';
const parser = new Parser();

(async () => {
  const feed = await parser.parseURL('<https://www.example.com/feed.xml>');
  console.log(feed.title);

  feed.items.forEach(item => {
    console.log(item.title);
  });
})();

Automatisation par jours:

Pour exécuter une fonction tous les jours à une heure spécifique en utilisant cron-node, vous pouvez suivre les étapes suivantes :

1. Tout d'abord, installez le module cron-node à l'aide de la commande npm suivante :

npm install cron

1. Ensuite, créez un fichier JavaScript et importez le module cron-node en utilisant la ligne suivante :

import CronJob from 'cron';

1. Créez une instance de l'objet CronJob en spécifiant l'heure d'exécution :

const job = new CronJob('0 0 19 * * *', function() {
  console.log('Fonction exécutée tous les jours à 19h.');
}, null, true, 'Europe/Paris');

Dans cet exemple, la fonction sera exécutée tous les jours à 19h. La chaîne de caractères '0 0 19 * * *' spécifie l'heure d'exécution en utilisant le format cron.

1. Vous pouvez également ajouter des paramètres de fonction à l'objet CronJob. Par exemple :

const job = new CronJob('0 0 19 * * *', function(param1, param2) {
  console.log('Fonction exécutée tous les jours à 19h avec les paramètres :', param1, param2);
}, null, true, 'Europe/Paris', ['paramètre 1', 'paramètre 2']);

Dans cet exemple, la fonction prend deux paramètres, qui sont spécifiés dans le tableau ['paramètre 1', 'paramètre 2'].

1. Enfin, activez l'objet CronJob en utilisant la méthode start() :

job.start();

Cela activera l'exécution régulière de la fonction tous les jours à l'heure spécifiée.

Remarque

Assurez-vous d'ajouter la ligne job.stop(); à la fin de votre fonction pour terminer le travail de façon sécurisée et éviter les problèmes de mémoire.

Reformulation

Si vous avez besoin de produire du texte de haute qualité et que la rapidité n'est pas une priorité, je recommande d'utiliser Text-Davinci-003 plutôt que GPT-3.5-turbo.

Text-Davinci-003 est un modèle de langage plus puissant que GPT-3.5-turbo, capable de générer des textes plus précis et plus cohérents. Bien qu'il soit plus lent que GPT-3.5-turbo en termes de temps d'inférence, cela ne devrait pas être un problème car vous n'aurez à exécuter l'action qu'une seule fois par jour sur un nombre raisonnable de textes.

De plus, étant donné que la qualité du texte est une priorité pour vous, Text-Davinci-003 peut vous offrir des résultats plus précis et plus naturels que GPT-3.5-turbo. En fin de compte, le choix dépend de vos besoins spécifiques, mais si vous recherchez la qualité plutôt que la rapidité, Text-Davinci-003 est une excellente option.

Si vous cherchez à reformuler un article avec Text-Davinci-003 sur Node.js en utilisant les derniers standards ES6, vous pouvez suivre les étapes suivantes :

1. Tout d'abord, installez le module openai en utilisant la commande npm suivante :

npm install openai

2. Ensuite, créez un fichier JavaScript et importez le module openai en utilisant la ligne suivante :

import { Configuration, OpenAIApi } from 'openai';

3. Configurez votre clé API OpenAI en créant un fichier .env contenant votre clé :

OPENAI_API_KEY=your_api_key_here

4. Configurer la connection avec une clé d’api stockée dans l’environnement

const openaiConfig = await new Configuration({
    apiKey: process.env.OPENAI_API_KEY,
  })
const openai = await new OpenAIApi(openaiConfig);

5. Utilisez la méthode openai.complete() pour envoyer une requête à l'API OpenAI et recevoir une réponse contenant la reformulation de l'article :

import { Configuration, OpenAIApi } from 'openai';
import dotenv from 'dotenv';

dotenv.config();

const text = 'Voici l\\'article que je souhaite reformuler.';
const prompt = `Reformulez cet article en utilisant des mots simples et un langage clair : \\n\\n ${text}`;

async function getRewrittenText() {
  const response = await openai.createCompletion({
    engine: 'text-davinci-003',
    prompt,
    maxTokens: 2048,
    n: 1,
    stop: '\\n\\n',
  });

  return response.data.choices[0].text.trim();
}

getRewrittenText().then((rewrittenText) => {
  console.log(rewrittenText);
});

6. Enfin, on ajoute la gestion des erreurs:

//Get the response from openai and handle errors
  try {
    response = await openai.createCompletion({
      model: 'text-davinci-003',
      prompt,
      max_tokens: 2048,
      n: 1,
      stop: '\\n\\n',
    });
  } catch (error) {
    if (error.response) {
      console.log(error.response.status);
      console.log(error.response.data);
    } else {
      console.log(error.message);
  }

Dans cet exemple, nous avons utilisé la méthode openai.complete() pour envoyer une requête à l'API OpenAI et recevoir une réponse contenant la reformulation de l'article. Nous avons spécifié l'engine text-davinci-003 pour utiliser le modèle de langage Text-Davinci-003, et nous avons configuré les paramètres maxTokens, n et stop pour contrôler la longueur et le format de la réponse.

En utilisant ces étapes, vous pouvez reformuler un article en utilisant Text-Davinci-003 sur Node.js en utilisant les derniers standards ES6.